#encoding:utf-8
'''
Created on 2015年7月7日

@author: LWD
'''

from bs4 import BeautifulSoup
import sys
from session import create_session

reload(sys)
session = None

class Question:
    '''
    @summary: 问题类，获取 存储 问题信息，包括问题ID,提问者，提问时间， 关注人数，答案数， 问题题目,问题正文,所属话题,是否被锁定, 访问数
    '''
    url = None
    soup = None

    def __init__(self, url, title = None):
        '''
        @summary: 构造函数，
        @param url: 问题的url
        @papam title: 问题的标题（默认为 None）
        '''
        if url[0:len(url) - 8] != "http://www.zhihu.com/question/":
            raise ValueError("\"" + url + "\"" + " : it isn't a question url.")
        else:
            self.url = url
            if title != None:
                self.title = title
    
    def parser(self):
        '''
        @summary: 获取指定网页的内容（content）,使用BeautifulSoup对页面解析 
        结果赋值给全局变量 session
        '''
        global session
        global cookies

        if session == None:
            # 如果没有创建登录会话，则创建登录会话
            session = create_session()
        s = session
        # 打开问题页
        r = s.get(self.url)
        # print r.content
        # 解析问题页面
        soup = BeautifulSoup(r.content)
        self.soup = soup

    def get_question_id(self):
        '''
        @summary: 问题id设置为 问题页面url最后一段
        @return: 如果url存在，则返回问题id，如果不存在，返回空0 （int）
        '''
        if self.url == None:
            return 0
        else:
            return self.url[-8:]

    def _get_element_from_content(self, label, lclass=None, lid=None, flag = 0):
        '''
        @summary: 根据标签和css类名或者id查找对应标签，如果同时设置了类名和 id，结果按照id查找 
        @param label: 要查找的HTML标签
        @param lclass: 要查找的标签的css类
        @param lid: 要查找的标签的id 
        @param flag: 0：查找结果只有一个值； 非0： 查找结果是一个元组
        @return: 查找结果，如果flag是0，返回一条结果，否则，返回的是一个元组
        '''
        # 没有页面地址，直接返回None
        if self.url == None:
            print "I'm anonymous user."
            return None
        else:
            # 如果没有下载页面,则下载并解析页面
            if self.soup == None:
                self.parser()
            soup = self.soup
            # 根据flag 执行不同的查找方式
            if lclass != None:
                if flag == 0:
                    # 查找结果只有一个
                    res = soup.find(label, class_=lclass)
                else:
                    # 查找所有符合要求的标签
                    res = soup.find_all(label, class_=lclass)
            # 如果设置了lid, 则根据id查找 标签
            if lid != None:
                res = soup.find(label, id=lid)
            if not res: # 结果是空
                return None
            return res

    def get_title(self):
        '''
        @summary: 获取问题的标题，如果不存在，返回默认值 空
        @return: 返回问题标题（字符串 编码:utf-8）
        '''
        if hasattr(self, "title"):
            return self.title.encode("utf-8")
        else:
            title = self._get_element_from_content("h2", lclass="zm-item-title zm-editable-content")
            if title == None:
                return ""
            return title.string.encode("utf-8").replace("\n", "")
        
        
    def get_detail(self):
        '''
        @summary: 获取问题详细内容，如果不存在返回默认值 空
        @return: 问题详细内容（字符串 编码：utf-8）
        '''
        detail = self._get_element_from_content("div", lid="zh-question-detail")
        if detail == None:
            return ""
        # 将html编辑为文本存储
        return detail.div.get_text().encode("utf-8")
    
    def get_topics(self):
        '''
        @summary: 获取问题所属的话题列表，如果不存在返回空列表
        @return: 话题列表（字符串数组，编码：utf-8）
        '''
        topic_list = self._get_element_from_content("a", lclass="zm-item-tag", flag=1)
        if topic_list == None:
            return ""
        topics = []
        for i in topic_list:
            topic = i.contents[0].encode("utf-8").replace("\n", "")
            topics.append(topic)
        return topics
    
    def get_answers_num(self):
        '''
        @summary: 获取问题的答案数，如果没有回答，返回0， 如果问题被锁定，则返回1 
        @return: 问题答案数（int）
        '''
        # 判断 如果问题被锁定，直接返回  答案数是 1
        if hasattr(self, "state") and self.state == 0:
            return 1
        # 获取问题答案数
        answers_num = self._get_element_from_content("h3", lid="zh-question-answer-num")
        # 没有答案数
        if answers_num == None:
            # 且有答案  则问题被锁定
            if self.has_answers():
                # 设置问题状态为 锁定
                self.state = 0
                return 1
            # 没有答案，则问题目前没有答案
            else:
                return 0
        return int(answers_num["data-num"])

    def get_followers_num(self):
        '''
        @summary: 获取问题的关注人数，如果获取不到 或者 没有关注者 返回默认值 0 
        @return: 问题关注人数（int）
        '''
        followers_num = self._get_element_from_content("div", lclass="zg-gray-normal")
        # 如果查询结果为None, 则返回默认值 0
        if followers_num == None or followers_num.a == None or followers_num.a.strong == None:
            return 0
        return int(followers_num.a.strong.string)
    
    def get_visit_times(self):
        '''
        @summary: 获取问题的访问次数，如果获取不到访问次数，或者 访问次数为0  则返回默认值 0
        @return: 访问次数（int）
        '''
        if self.soup == None:
            self.parser()
        soup = self.soup
        # 由于 查找条件的属性是  itemprop，没有使用 _get_element_from_content方法
        visit_times = soup.find("meta", itemprop="visitsCount")
        if visit_times == None:
            return 0
        return int(visit_times["content"])

    def get_question_state(self):
        '''
        @summary: 获取问题状态，问题是否被锁定, 注意，当问题被锁定后，实际获取的页面
        没有 锁定的标签，判断获取到的答案数 以及 是否可以获取第一个答案来判断是否被锁定
        @return: 问题当前状态，1 表示 锁定  0 表示 可编辑
        '''
        if hasattr(self, "state"):
            return self.state
        answers_num = self._get_element_from_content("h3", lid="zh-question-answer-num")
        # 没有答案数  且 至少有一个答案，问题是锁定的
        if answers_num == None and self.has_answers():
            # disable
            return 0 
        # 问题没有被锁定
        # enable
        return 1
        

    def get_question_author_and_ctime(self):
        '''
        @summary: 获取问题  提问者（author  user_id） 和 提问时间（create time）， 如果没有，则返回（匿名用户，""）
        @return: (author, ctime)元组（用户名：字符串，编码utf-8  创建时间 ：YYYY-MM-DD hh:mm:ss）
        '''
        global session
        if session == None:
            session = create_session()
        s = session
        followee_url = self.url + "/log"
        r = s.get(followee_url)
        soup = BeautifulSoup(r.content)
        items = soup.find_all("div", class_="zm-item")
        author_info = items[len(items)-1]
        ctime = author_info.find("div", class_="zm-item-meta").time.string
        if author_info.div.a.string == "匿名用户":
            author = 0
        else:
            author = (author_info.div.a["href"])[8:]
        return (author, ctime)
    
    def has_answers(self):
        '''
        @summary: 判断有没有答案div
        @return: 如果有答案，则返回True， 否则返回False
        '''
        answers = self._get_element_from_content("div", lid="zh-question-answer-wrap")
        if answers == None:
            return False
        return True
    
    def get_answers(self):
        '''
        @summary: 获取问题下的所有答案
        '''
        pass
